Тема 2. Процессы и задания в прикладном программном интерфейсе

План лекции

1. Прикладной системный интерфейс управления ресурсами

1.1. Управление системными ресурсами

2. Понятие процесса и управление процессами

2.1. Что такое процесс?

2.2. Состояния процесса

2.3. Создание процессов

В Windows (WinAPI):

#include <windows.h>

STARTUPINFO si = { sizeof(si) };
PROCESS_INFORMATION pi;

CreateProcess(
    "program.exe",    // Имя исполняемого файла
    NULL,             // Командная строка
    NULL,             // Атрибуты безопасности процесса
    NULL,             // Атрибуты безопасности потока
    FALSE,            // Наследование дескрипторов
    0,                // Флаги создания
    NULL,             // Окружение
    NULL,             // Текущий каталог
    &si,              // STARTUPINFO
    &pi               // PROCESS_INFORMATION
);

2.4. Создание процессов в Linux

#include <unistd.h>
#include <sys/wait.h>

pid_t pid = fork();

if (pid < 0) {
    // Ошибка создания процесса
} else if (pid == 0) {
    // Код дочернего процесса
    execl("/bin/ls", "ls", "-l", NULL);
} else {
    // Код родительского процесса
    wait(NULL);  // Ожидание завершения дочернего
}

3. Концепция виртуализации

3.1. Виртуализация ресурсов

Виртуализация — технология, позволяющая представить физические ресурсы в виде логических, абстрагированных от аппаратной реализации.

Виды виртуализации:

3.2. Виртуальное адресное пространство

Высокие адреса — сверху (Стек), Низкие адреса — снизу (Зарезервировано ядром)

3.3. Контейнеризация в Linux

Namespaces (пространства имён)

Namespaces — механизм изоляции ресурсов процесса.

Пример создания namespace:

#define _GNU_SOURCE
#include <sched.h>
#include <stdio.h>
#include <unistd.h>

static int child_func(void* arg) {
    printf("Child PID: %d\n", getpid());
    return 0;
}

int main() {
    char stack[1024*1024];
    
    pid_t pid = clone(child_func, stack + sizeof(stack),
                       CLONE_NEWPID | SIGCHLD, NULL);
    
    printf("Parent PID: %d, Child: %d\n", getpid(), pid);
    waitpid(pid, NULL, 0);
    return 0;
}

Cgroups (контрольные группы)

Cgroups — механизм ограничения и учёта ресурсов.

Подсистемы (контроллеры):

Пример ограничения памяти (cgroups v2):

# Создание группы
sudo mkdir /sys/fs/cgroup/mygroup

# Установка лимита памяти (100 MB)
echo 100M > /sys/fs/cgroup/mygroup/memory.max

# Добавление процесса
echo $$ > /sys/fs/cgroup/mygroup/cgroup.procs

Контейнеры vs Виртуальные машины

Сравнение:

3.4. Подходы к контейнеризации: Docker, Podman, containerd, LXC

Docker — наиболее распространённая платформа контейнеризации с клиент-серверной архитектурой (демон dockerd).

Podman — альтернативный движок контейнеризации от Red Hat:

• Не требует демона (daemonless)
• Поддержка rootless-контейнеров (запуск без прав root)
• Концепция pod — группа контейнеров, аналогичная Kubernetes Pod
• CLI совместимость с Docker

podman run -d --name web nginx:latest
podman build -t myapp .
podman pod create --name mypod
podman run -d --pod mypod redis:latest

containerd — runtime-компонент контейнеризации:

• Используется Docker и Kubernetes как низкоуровневый runtime
• Реализует CRI (Container Runtime Interface)
• Работает на более низком уровне, чем Docker
• Отвечает за: pull образов, создание контейнеров, управление жизненным циклом

Сравнение инструментов контейнеризации:

3.5. Безопасность и песочница (sandboxing) процессов

Почему изоляция процессов важна для безопасности:

• Уязвимость в одном процессе не должна compromise всю систему
• Контейнеры и сервисы должны иметь минимально необходимые привилегии
• Поверхность атаки (attack surface) зависит от доступных системных вызовов и ресурсов

chroot — базовая изоляция файловой системы

chroot — изменение корневого каталога для процесса и его потомков.

#include <unistd.h>

chroot("/path/to/new/root");
chdir("/");

sudo chroot /path/to/new/root /bin/bash

Ограничения chroot:

• Не изолирует PID, сеть, IPC
• Root-пользователь может выйти (chroot escape)
• Только файловая изоляция — не полноценная песочница

Namespaces с точки зрения безопасности

Linux namespaces — не только изоляция для контейнеров, но и механизм безопасности:

Пример USER namespace (rootless-контейнер):

unshare --user --map-root-user bash
id

seccomp — фильтрация системных вызовов

seccomp (Secure Computing Mode) — ограничение системных вызовов процесса.

seccomp-bpf — фильтрация на основе правил BPF (Berkeley Packet Filter).

#include <seccomp.h>
#include <sys/prctl.h>

prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0);

scmp_filter_ctx ctx = seccomp_init(SCMP_ACT_ERRNO(1));

seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(read), 0);
seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(write), 0);
seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(exit), 0);
seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(exit_group), 0);

seccomp_load(ctx);
seccomp_release(ctx);

AppArmor и SELinux — Mandatory Access Control

aa-status
getenforce

Windows Job Objects — ресурсы и безопасность

Job Objects в Windows позволяют:

• Ограничение CPU-времени для группы процессов
• Ограничение рабочего множества памяти (working set)
• Ограничение приоритета процессов
• Завершение всех процессов в Job при закрытии

HANDLE hJob = CreateJobObject(NULL, L"MyJob");

JOBOBJECT_BASIC_LIMIT_INFORMATION jbli = {0};
jbli.LimitFlags = JOB_OBJECT_LIMIT_PROCESS_TIME;
jbli.PerProcessUserTimeLimit.QuadPart = 10000000;

SetInformationJobObject(hJob, JobObjectBasicLimitInformation,
                        &jbli, sizeof(jbli));

AssignProcessToJobObject(hJob, hProcess);

Техники песочницы (sandboxing)(1/2)

Комплексный подход к изоляции:

• Сброс capabilities — ограничение привилегий (Linux capabilities)
• Только для чтения файловая система — предотвращение модификации
• Сетевые ограничения — изоляция или запрет сети
• Лимиты ресурсов — cgroups / Job Objects
• Монтирование tmpfs — временное хранение данных

capsh --drop=cap_net_raw --drop=cap_sys_admin -- \
    --chroot=/sandbox -- /bin/bash

Техники песочницы (sandboxing)(2/2)

4. Управление группами процессов

4.1. Иерархия процессов

// Создание новой группы процессов
setpgid(pid, pgid);

// Создание новой сессии
setsid();

// Отправка сигнала группе
kill(-pgid, SIGTERM);

4.2. Сигналы процессам

Основные сигналы UNIX:

5. Понятие многопоточности

5.1. Потоки выполнения

5.2. Модели потоков

Модели реализации потоков:

Модель 1:1 (One-to-One)

Модель Many-to-One

Модель Many-to-Many

6. Методы управления потоками

6.1. Создание потоков в Windows

#include <windows.h>

DWORD WINAPI ThreadFunc(LPVOID lpParam) {
    // Код потока
    return 0;
}

HANDLE hThread = CreateThread(
    NULL,              // Атрибуты безопасности
    0,                 // Размер стека
    ThreadFunc,        // Функция потока
    &param,            // Параметр
    0,                 // Флаги создания
    &threadId          // ID потока
);

WaitForSingleObject(hThread, INFINITE);
CloseHandle(hThread);

6.2. Создание потоков в POSIX

#include <pthread.h>

void* thread_func(void* arg) {
    // Код потока
    pthread_exit(NULL);
}

pthread_t thread;
int result = pthread_create(
    &thread,      // Идентификатор потока
    NULL,         // Атрибуты
    thread_func,  // Функция
    &param        // Аргумент
);

pthread_join(thread, NULL);

7. Организация параллельной обработки

7.1. Параллелизм и конкурентность

Конкурентность — способность системы обрабатывать несколько задач, чередуя их выполнение.

Параллелизм — одновременное выполнение нескольких задач.

Уровни параллелизма:

• Межпроцессный — независимые процессы
• Межпоточный — потоки одного процесса
• Внутрипоточный — инструкции (конвейеризация)

Преимущества:

• Повышение производительности
• Лучшее использование ресурсов
• Отзывчивость приложений

7.2. Проблемы параллельной обработки

Основные проблемы:

• Состояние гонки (Race Condition)
• Взаимная блокировка (Deadlock)
• Голодание (Starvation)
• Проблема ABA

Пример состояния гонки:

// Общая переменная
int counter = 0;

// Поток 1          // Поток 2
int temp = counter;  int temp = counter;
temp++;              temp++;
counter = temp;      counter = temp;
// Результат: counter = 1 (вместо 2!)

8. Асинхронное выполнение системных вызовов

8.1. Синхронный vs Асинхронный ввод-вывод

Синхронный (блокирующий):

// Поток блокируется до завершения операции
ReadFile(hFile, buffer, size, &read, NULL);
// Выполнение продолжается только после чтения

Асинхронный (неблокирующий):

OVERLAPPED ov = {0};
ReadFileEx(hFile, buffer, size, &ov, CompletionCallback);
// Поток продолжает выполнение
// Callback вызывается по завершении

8.2. Механизмы асинхронности

int epfd = epoll_create1(0);
struct epoll_event ev, events[10];
ev.events = EPOLLIN;
ev.data.fd = sockfd;
epoll_ctl(epfd, EPOLL_CTL_ADD, sockfd, &ev);
int nfds = epoll_wait(epfd, events, 10, -1);

9. Удаленный запуск приложений

9.1. Механизмы удаленного выполнения

Способы удаленного запуска:

• SSH — безопасное удаленное выполнение (Linux)
• RPC — удаленный вызов процедур
• DCOM/COM+ — распределенные объекты (Windows)
• WMI — Windows Management Instrumentation

Пример SSH:

# Выполнение команды на удаленном хосте
ssh user@remote_host "ls -la"

# Копирование файлов
scp file.txt user@remote_host:/path/

9.2. RPC (Remote Procedure Call)

Концепция RPC:

Резюме

Ключевые моменты лекции:

1. Процесс — изолированная единица выполнения с собственными ресурсами
2. Виртуализация — абстракция физических ресурсов
3. Namespaces и cgroups — механизмы изоляции для контейнеров
4. Docker, Podman, containerd, LXC — экосистема контейнеризации
5. Потоки — легковесные единицы выполнения внутри процесса
6. Параллельная обработка — требует синхронизации
7. Асинхронный I/O — повышает производительность
8. Удаленный запуск — распределенные вычисления
9. seccomp, AppArmor/SELinux — механизмы безопасности и песочница процессов

Вопросы для самопроверки

1. Чем отличается процесс от потока?
2. Какие состояния может иметь процесс?
3. Что такое виртуальное адресное пространство?
4. Какие namespaces существуют в Linux?
5. Как работают cgroups?
6. Какие модели потоков существуют?
7. Что такое состояние гонки и как его избежать?
8. Какие механизмы асинхронного ввода-вывода существуют?
9. Как работает механизм RPC?

Практические задания

Самостоятельная работа (8 часов):

1. Написать программу, создающую дочерний процесс (fork/clone)
2. Исследовать /proc/[pid]/ для анализа процессов
3. Создать простую программу с использованием pthread
4. Изучить работу namespaces на примере unshare

Рекомендуемая литература